package principal;

import hibernate.Facade;
import hibernateDAOS.CompraDAO;
import hibernateDAOS.MozoDAO;
import hibernateDAOS.OrdenCompraDAO;
import hibernateDAOS.ProductoDAO;
import interfaces.AdministracionCentralInterface;

import java.io.IOException;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;

import xml.WriteXMLOrdenCompra;

import excepciones.ProductoException;
import excepciones.ProveedorException;


import beans.*;


public class AdministracionCentral extends UnicastRemoteObject implements AdministracionCentralInterface
{
   
	private static AdministracionCentral instancia;

	private static final long serialVersionUID = -101608456035607677L;
	
	private List<sucursalWeb> sucursales;
    private List<Proveedor> proveedores;
    private List<Remito> remitos;
    private List<Producto> productos;
    private Deposito depositoCentral;
    private List<OrdenCompra> ordenesDeCompra;
    private List<RecepcionMercaderia> recepcionesMercaderia;
    private List<Movimiento> movimientos;
    private List<Producto> productosSolicitados;
    private List<Compra> comprasAHacer;
    
    
    public static AdministracionCentral obtenerInstancia() throws RemoteException
    {
    	if ( instancia == null )
    	{
    		instancia = new AdministracionCentral();
    	}
    	return instancia;
    }
    
    public List<Producto> getProductosSolicitados() {
		return productosSolicitados;
	}

	public void setProductosSolicitados(List<Producto> productosAReponer) {
		this.productosSolicitados = productosAReponer;
	}

	public AdministracionCentral() throws RemoteException 
    {	
    	sucursales = new ArrayList<sucursalWeb>();
    	proveedores = new ArrayList<Proveedor>();
    	remitos = new ArrayList<Remito>();
    	productos = new ArrayList<Producto>();
    	depositoCentral = new DepositoCentral();
    	ordenesDeCompra = new ArrayList<OrdenCompra>();
    	recepcionesMercaderia = new ArrayList<RecepcionMercaderia>();
    	productosSolicitados = new ArrayList<Producto>();
    }
    
    public void generarOrdenCompra()
    {
    
    }
    
    public void crearMovimiento(int idProducto, int  cantidad, Calendar fechaMovimiento, String tipoMov ,int idDepositoDestino) throws ProductoException
    {
    	Movimiento m = new Movimiento();
    	Producto p = buscarProducto( idProducto );
    	Deposito dep = obtenerDeposito ( idDepositoDestino );
    	if ( p != null && dep != null )
    	{
    		m.setProducto(p);
    		m.setCantidad(cantidad);
    		m.setFechaMovimiento(fechaMovimiento);
    		m.setDepositoOrigen(depositoCentral);
    		m.setDepositoDestino(dep);
    		
    		movimientos.add(m);
    		if( "salida".equalsIgnoreCase(tipoMov) )
    		{
    			dep.restarMercaderia(cantidad, p );
    		}
    		Facade.obtenerInstancia().guardarMovimiento(m);
    		
    	}
    }
    
    private Deposito obtenerDeposito(int idDepositoDestino) {
		// TODO Auto-generated method stub
		return null;
	}

	public void administrarPlanesProduccion()
    {
    	MozoDAO.getInstancia().guardarMozo(new Mozo("Leo", 8));
//    	ProductoDAO.getInstancia().guardarProducto(new Producto("Leche",7,8,"caducidad","unidadCompra","unidadUso"));
    }
    
    public void checkearOfertas()
    {
    
    }
    
    public void controlarCompras()
    {
    
    }
    
    public Producto buscarProducto ( int idProducto ) throws ProductoException
    {
    	Producto p = null;
    	
    	for ( Producto prod : productos ) 
    	{
    		if ( idProducto == p.getIdProducto() )
    		{
    			p = prod;
    		}
		}
    	if ( p == null )
    	{
    		Producto p2 = Facade.obtenerInstancia().obtenerProducto(idProducto);
    		if ( p2 != null )
    		{
    			return p2;
    		}
    		else
    		{
    			throw new ProductoException( ProductoException.PRODUCTO_INEXISTENTE );
    		}
    	}
    	return p;
    }

    public Proveedor obtenerProveXNombre ( String nombProve ) throws ProveedorException
    {
    	Proveedor pr = null;
    	
    	for ( Proveedor prove : proveedores ) 
    	{
    		if ( nombProve.equalsIgnoreCase( prove.getNombre() ) )
    		{
    			pr = prove;
    		}
		}
    	if ( pr == null )
    	{
    		Proveedor pr2 = Facade.obtenerInstancia().obtenerProveXNombre( nombProve );
    		if ( pr2 != null )
    		{
    			return pr2;
    		}
    		else
    		{
    			throw new ProveedorException( ProveedorException.PROVEEDOR_INEXISTENTE );
    		}
    	}
    	return pr;
    }
    
    
    public List<Proveedor> obtenerProveedores ()
    {
    	return Facade.obtenerInstancia().obtenerProveedores();
    }
  
	@Override
	public void crearMovimiento(int idProducto, int cantidad,
			Calendar fechaMovimiento, int idDeposito) throws RemoteException {
		// TODO Auto-generated method stub
		
	}
	
	public void armarOCparaProveedores(OrdenCompra oc) throws IOException{
		
		WriteXMLOrdenCompra.guardarXMLOrdenCompra(oc);
		
//		List<ItemOrdenCompra> lista = OrdenCompraDAO.getInstancia().obtenerOCsNoAtendidas();
//		for(Iterator<ItemOrdenCompra> i = lista.iterator();i.hasNext();){
//			ItemOrdenCompra itemOC = i.next();
//			
//			if(itemOC.getCantidad()!=0){ //no fue considerado
//				int cantidad = itemOC.getCantidad();
//				itemOC.setCantidad(0); //indica que ya fue considerado, y ya se armo su XML
//				
//				for(ItemOrdenCompra item2:lista){				
//					if(itemOC.getRodamiento().getIdRodamiento()==item2.getRodamiento().getIdRodamiento()&&item2.getCantidad()!=0){
//						cantidad += item2.getCantidad();
//						item2.setCantidad(0);
//						System.out.println(cantidad);
//					}
//				}
//				
//				OrdenCompraDeProveedor orden = new OrdenCompraDeProveedor();
//				
//				double precio = itemOC.getPrecio();
//				Proveedor proveedor = itemOC.getListaDePrecios().getProveedor();
//				Rodamiento rodamiento = itemOC.getRodamiento();
//				
//				orden.setCantidad(cantidad);
//				orden.setCantidadARecibir(cantidad);
//				orden.setPrecio(precio);
//				orden.setProveedor(proveedor);
//				orden.setRodamiento(rodamiento);
//				daos.OrdenCompraDeProveedorDAO.getInstancia().guardarOrdenCompraDeProveedor(orden);
//				
//				xml.WriteXML.guardarXML(orden);
//				daos.OrdenCompraOFDAO.getInstancia().marcarComoAtendidas();
//			}
//		}		
	}

	@Override
	public Producto obtenerProductoXNombre( String nombreProd ) throws RemoteException, ProductoException
	{
		
		Producto prod = null;
    	if ( productos.isEmpty() )
    	{
    		productos = ProductoDAO.getInstancia().obtenerProductos();
    	}
    	for ( Producto producto : productos ) 
    	{
    		if ( nombreProd.equalsIgnoreCase( producto.getNombre() ) )
    		{
    			prod = producto;
    		}
		}
    	if ( prod == null )
    	{
    		Producto prod2 = Facade.obtenerInstancia().obtenerProductoXNombre( nombreProd );
    		if ( prod2 != null )
    		{
    			return prod2;
    		}
    		else
    		{
    			throw new ProductoException( ProductoException.PRODUCTO_INEXISTENTE );
    		}
    	}
    	return prod;
	}

	@Override
	public List<Compra> listaReposicionInsumos( ) throws RemoteException 
	{
		
		List<Compra> productosAReponer = new ArrayList<Compra>();
		List<Compra> productosPedidos = new ArrayList<Compra>();
		productosPedidos = CompraDAO.getInstancia().obtenerCompras();
		for ( Compra comp : productosPedidos ) 
		{
			if ( !verificarExistencia( comp.getProductoAComprar() ) )
			{
				productosAReponer.add( comp );
			}
		}
		
		return productosAReponer;
	}
//	private Compra obtenerCompra(Producto producto)
//	{
//		Compra c = new Compra();
//		StockProducto sp = depositoCentral.obtenerStockProdDeProducto(producto);
//		if ( sp != null )
//		{
//			c.setProductoAComprar(producto);
//			c.setCantidadAComprar(sp.getcantidadAComprar());
//		}
//		else 
//		{
//			c.setProductoAComprar(producto);
//			c.setCantidadAComprar(100);
//		}
//		return c;
//	}


	public void obtenerCompras ()
	{
		comprasAHacer = CompraDAO.getInstancia().obtenerCompras();
	}
	
	
	private boolean verificarExistencia( Producto producto ) 
	{
		return depositoCentral.verificarExistenciaProducto( producto );
	}
	
//	public void crearOrdenesDeCompra( List<Producto> productos )throws RemoteException 
//	{
//		System.out.println(productos.get(0).getNombre());
//	}

	public List<Compra> getComprasAHacer() {
		return comprasAHacer;
	}

	public void setComprasAHacer(List<Compra> comprasAHacer) {
		this.comprasAHacer = comprasAHacer;
	}


}
